¿Cómo puedo eliminar un elemento específico de una matriz?

1
2
3
4
Siguiente
Busque el índice del elemento de matriz que desea eliminar usando indexOf y luego elimine ese índice con empalme.
El método splice () cambia el contenido de una matriz eliminando
elementos existentes y / o agregando elementos nuevos.
matriz constante = [2, 5, 9];
console.log (matriz);
índice constante = array.indexOf (5);
if (índice> -1) {
array.splice (índice, 1);
}
// matriz = [2, 9]
console.log (matriz);
El segundo parámetro de empalme es el número de elementos a eliminar. Tenga en cuenta que empalmar modifica la matriz en su lugar y devuelve una nueva matriz que contiene los elementos que se han eliminado.
Por razones de integridad, aquí hay funciones. La primera función elimina solo una aparición (es decir, elimina la primera coincidencia de 5 de [2,5,9,1,5,8,5]), mientras que la segunda función elimina todas las apariciones:
function removeItemOnce (arr, value) {
var index = arr.indexOf (valor);
if (índice> -1) {
arr.splice (índice, 1);
}
return arr;
}
function removeItemAll (arr, value) {
var i = 0;
while (i  = 0; i--) {
si (matriz [i] === número) {
array.splice (i, 1);
}
}
Si solo desea que el elemento en el índice i ya no exista, pero no desea que los índices de los otros elementos cambien:
eliminar matriz [i];
|
Editado en octubre de 2016
Hazlo simple, intuitivo y explícito (navaja de Occam)
Hazlo inmutable (la matriz original permanece sin cambios)
Hágalo con funciones estándar de JavaScript, si su navegador no las admite, use polyfill
En este ejemplo de código, uso la función "array.filter (...)" para eliminar elementos no deseados de una matriz. Esta función no cambia la matriz original y crea una nueva. Si su navegador no admite esta función (por ejemplo, Internet Explorer antes de la versión 9 o Firefox antes de la versión 1.5), considere usar el filtro polyfill de Mozilla.
Eliminación de elemento (código ECMA-262 Edición 5 también conocido como JavaScript de estilo antiguo)
valor var = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (función (elemento) {
devolver artículo! == valor
})
console.log (arr)
// [1, 2, 4, 5]
Eliminar elemento (código ECMAScript 6)
dejar valor = 3
sea ​​arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
IMPORTANTE La sintaxis de la función de flecha ECMAScript 6 "() => {}" no es compatible con Internet Explorer, Chrome antes de la versión 45, Firefox antes de la versión 22 y Safari antes de la versión 10. Para usar la sintaxis de ECMAScript 6 en navegadores antiguos, puede usar BabelJS.
Eliminación de varios elementos (código ECMAScript 7)
Una ventaja adicional de este método es que puede eliminar varios elementos
let forDeletion = [2, 3, 5]
sea ​​arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Lea a continuación sobre la compatibilidad con array.includes (...) !!!
console.log (arr)
// [1, 4]
IMPORTANTE La función "array.includes (...)" no es compatible en absoluto con Internet Explorer, Chrome antes de la versión 47, Firefox antes de la versión 43, Safari antes de la versión 9 y Edge antes de la versión 14, así que aquí está polyfill de Mozilla.
Eliminar varios elementos (en el futuro, tal vez)
Si alguna vez se acepta la propuesta "Esta sintaxis vinculante", podrá hacer lo siguiente:
// array-lib.js
función de exportación remove (... forDeletion) {
devuelve this.filter (item =>! forDeletion.includes (item))
}
// main.js
importar {eliminar} de './array-lib.js'
sea ​​arr = [1, 2, 3, 4, 5, 3]
// :: Propuesta de sintaxis de esta vinculación
// usar la función "eliminar" como "método virtual"
// sin extender Array.prototype
arr = arr :: eliminar (2, 3, 5)
console.log (arr)
// [1, 4]
Pruébelo usted mismo en BabelJS :)
Referencia
Array.prototype.include
Composición funcional
|
Depende de si quieres mantener un espacio vacío o no.
Si desea un espacio vacío:
matriz [índice] = indefinido;
Si no quiere un espacio vacío:
// Para conservar el original:
// oldArray = [... matriz];
// Esto modifica la matriz.
array.splice (índice, 1);
Y si necesita el valor de ese elemento, puede almacenar el elemento de la matriz devuelta:
valor var = array.splice (índice, 1) [0];
Si desea eliminar en cualquier extremo de la matriz, puede usar array.pop () para el último o array.shift () para el primero (ambos devuelven el valor del elemento también).
Si no conoce el índice del elemento, puede usar array.indexOf (elemento) para obtenerlo (en un if () para obtener un elemento o en un while () para obtenerlos todos). array.indexOf (item) devuelve el índice o -1 si no se encuentra.
|
Un amigo tenía problemas con Internet Explorer 8 y me mostró lo que hizo. Le dije que estaba mal y me dijo que tenía la respuestaaquí. La respuesta principal actual no funcionará en todos los navegadores (Internet Explorer 8, por ejemplo) y solo eliminará la primera aparición del elemento.
Eliminar TODAS las instancias de una matriz
función array_remove_index_by_value (arr, elemento)
{
para (var i = longitud de arr.; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Recorre la matriz hacia atrás (ya que los índices y la longitud cambiarán a medida que se eliminan los elementos) y elimina el elemento si se encuentra. Funciona en todos los navegadores.
|
Hay dos enfoques principales:
empalme (): anArray.splice (índice, 1);
eliminar: eliminar unArray [índice];
Tenga cuidado cuando use delete para una matriz. Es bueno para eliminar atributos de objetos, pero no tan bueno para matrices. Es mejor utilizar empalmes para matrices.
Tenga en cuenta que cuando usa delete para una matriz, puede obtener resultados incorrectos para anArray.length. En otras palabras, delete eliminaría el elemento, pero no actualizaría el valor de la propiedad length.
También puede esperar tener agujeros en los números de índice después de usar eliminar, p. podría terminar teniendo los índices 1, 3, 4, 8, 9 y 11 y la longitud que tenía antes de usar delete. En ese caso, todos los bucles for indexados se bloquearían, ya que los índices ya no son secuenciales.
Si se ve obligado a usar delete por alguna razón, entonces debe usar para cada bucle cuando necesite recorrer arreglos. De hecho, siempre evite usar bucles for indexados, si es posible. De esa manera, el código sería más robusto y menos propenso a problemas con los índices.
|
Array.prototype.remove_by_value = function (val) {
para (var i = 0; i  row.id === 5);
var eliminado = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definición
var helper = {
// Eliminar y devolver la primera aparición
removeOne: function (matriz, predicado) {
para (var i = 0; i  [2, 3, 4]
|
Puede utilizar ES6. Por ejemplo, para eliminar el valor '3' en este caso:
var matriz = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((valor) => valor! = '3');
console.log (newArray);
Salida:
["1", "2", "4", "5", "6"]
|
Si desea una nueva matriz con las posiciones eliminadas eliminadas, siempre puede eliminar el elemento específico y filtrar la matriz. Es posible que necesite una extensión del objeto de matriz para los navegadores que no implementan el método de filtro, pero a largo plazo es más fácil ya que todo lo que hace es esto:
var my_array = [1, 2, 3, 4, 5, 6];
eliminar my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Debería mostrar [1, 2, 3, 4, 6].
|
A continuación, se muestran algunas formas de eliminar un elemento de una matriz mediante JavaScript.
Todos los métodos descritos no mutan la matriz original, sino que crean una nueva.
Si conoce el índice de un artículo
Suponga que tiene una matriz y desea eliminar un elemento en la posición i.
Un método es usar slice ():
elementos const = ['a', 'b', 'c', 'd', 'e', ​​'f']
constante i = 3
const filterItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (artículos filtrados)
slice () crea una nueva matriz con los índices que recibe. Simplemente creamos una nueva matriz, desde el inicio hasta el índice que queremos eliminar, y concatenamos otra matriz desde la primera posición después de la que eliminamos hasta el final de la matriz.
Si conoces el valor
En este caso, una buena opción es usar filter (), que ofrece un enfoque más declarativo:
elementos const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
elementos filtrados const = elementos.filtro (elemento => elemento! == valor para eliminar)
console.log (artículos filtrados)
Utiliza las funciones de flecha de ES6. Puede utilizar las funciones tradicionales para admitir navegadores más antiguos:
elementos const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
elementos filtrados const = elementos.filtro (función (elemento) {
devolver artículo! == valueToRemove
})
console.log (artículos filtrados)
o puede utilizar Babel y transpilar el código ES6 de nuevo a ES5 para hacerlo más digerible para los navegadores antiguos, pero escribir JavaScript moderno en su código.
Eliminar varios elementos
¿Qué sucede si en lugar de un solo elemento, desea eliminar muchos elementos?
Busquemos la solución más simple.
Por índice
Puede simplemente crear una función y eliminar elementos en serie:
elementos const = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (elementos, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
dejar filterItems = removeItem (elementos, 3)
FilterItems = removeItem (artículos filtrados, 5)
//["a B C D"]
console.log (artículos filtrados)
Por valor
Puede buscar la inclusión dentro de la función de devolución de llamada:
elementos const = ['a', 'b', 'c', 'd', 'e', ​​'f']
valores constToRemove = ['c', 'd']
elementos filtrados const = elementos.filtro (elemento =>! valores para eliminar.incluye (elemento))
// ["a", "b", "e", "f"]
console.log (artículos filtrados)
Evite mutar la matriz original
splice () (no confundir con slice ()) muta la matriz original y debe evitarse.
(publicado originalmente en mi sitio https://flaviocopes.com/how-to-remove-item-from-array/)
|
Mira este código. Funciona en todos los navegadores principales.
remove_item = function (arr, value) {
var b = '';
para (b en arr) {
if (arr [b] === valor) {
arr. empalme (b, 1);
romper;
}
}
return arr;
};
Llamar a esta función
remove_item (matriz, valor);
|
ES6 y sin mutación: (octubre de 2016)
const removeByIndex = (lista, índice) =>
[
... list.slice (0, índice),
... list.slice (índice + 1)
];
salida = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (salida)
|
Puede usar lodash _.pull (mutate matriz), _.pullAt (mutate matriz) o _.without (no muta matriz)
var array1 = ['a', 'b', 'c', 'd']
_.pull (matriz1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (matriz2, 0)
console.log (matriz2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
La eliminación de un elemento / cadena en particular de una matriz se puede hacer en una sola línea:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
dónde:
theArray: la matriz de la que desea eliminar algo en particular
stringToRemoveFromArray: la cadena que desea eliminar y 1 es la cantidad de elementos que desea eliminar.
NOTA: Si "stringToRemoveFromArray" no se encuentra en su matriz, esto eliminará el último elemento de la matriz.
Siempre es una buena práctica comprobar si el elemento existe en su matriz primero, antes de eliminarlo.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Si tiene acceso a versiones más recientes de Ecmascript en las computadoras de su cliente (ADVERTENCIA, es posible que no funcione en estaciones más antiguas):
var matriz = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((valor) => valor! = '3');
Donde '3' es el valor que desea eliminar de la matriz.
La matriz se convertiría en: ['1', '2', '4', '5', '6']
|
Bien, por ejemplo, tiene la siguiente matriz:
var num = [1, 2, 3, 4, 5];
Y queremos eliminar el número 4. Simplemente puede usar el siguiente código:
num.splice (num.indexOf (4), 1); // num será [1, 2, 3, 5];
Si está reutilizando esta función, escriba una función reutilizable que se adjuntará a la función de matriz nativa como se muestra a continuación:
Array.prototype.remove = Array.prototype.remove || función (x) {
const i = this.indexOf (x);
si (i === - 1)
regreso;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Pero, ¿qué tal si tiene la siguiente matriz en lugar de algunos [5] s en la matriz?
var num = [5, 6, 5, 4, 5, 1, 5];
Necesitamos un ciclo para verificarlos todos, pero una forma más fácil y eficiente es usar funciones de JavaScript integradas, por lo que escribimos una función que usa un filtro como el siguiente:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Devuelve [1, 2, 3, 4, 6]
También hay bibliotecas de terceros que te ayudan a hacer esto, como Lodash o Underscore. Para obtener más información, consulte lodash _.pull, _.pullAt o _.without.
|
Actuación
Hoy (2019-12-09) realizo pruebas de rendimiento en macOS v10.13.6 (High Sierra) para las soluciones elegidas. Muestro delete (A), pero no lo uso en comparación con otros métodos, porque dejó un espacio vacío en la matriz.
Las conclusiones
la solución más rápida es array.splice (C) (excepto Safari para arreglos pequeños donde tiene la segunda vez)
para arreglos grandes, array.slice + splice (H) es la solución inmutable más rápida para Firefox y Safari; Array.from (B) es más rápido en Chrome
Las soluciones mutables suelen ser entre 1,5 y 6 veces más rápidas que las inmutables.
para mesas pequeñas en Safari, sorprendentemente la solución mutable (C) es más lenta que la solución inmutable (G)
Detalles
En las pruebas, elimino el elemento intermedio de la matriz de diferentes maneras. Las soluciones A, C están en su lugar. Las soluciones B, D, E, F, G, H son inmutables.
Resultados para matriz con 10 elementos
En Chrome, array.splice (C) es la solución local más rápida. El array.filter (D) es la solución inmutable más rápida. El más lento es array.slice (F). Puede realizar la prueba en su máquina aquí.
Resultados para matriz con 1.000.000 elementos
En Chrome, array.splice (C) es la solución local más rápida (la eliminación (C) es similar rápida, pero dejó una ranura vacía en la matriz (por lo que no realiza una 'eliminación completa')). Array.slice-splice (H) es la solución inmutable más rápida. El más lento es array.filter (D y E). Puede realizar la prueba en su máquina aquí.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letra, matriz) => console.log (letra, matriz.join `,`);
función A (matriz) {
var index = array.indexOf (5);
eliminar matriz [índice];
log ('A', matriz);
}
función B (matriz) {
var index = array.indexOf (5);
var arr = Array.from (arreglo);
arr.splice (índice, 1)
log ('B', arr);
}
función C (matriz) {
var index = array.indexOf (5);
array.splice (índice, 1);
log ('C', matriz);
}
función D (matriz) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
función E (matriz) {
var index = array.indexOf (5);
var arr = array.filter ((elemento, i) => i! == índice)
log ('E', arr);
}
función F (matriz) {
var index = array.indexOf (5);
var arr = array.slice (0, índice) .concat (array.slice (índice + 1))
log ('F', arr);
}
función G (matriz) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}
función H (matriz) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (índice, 1);
log ('H', arr);
}
Automóvil club británico]);
Licenciado en Letras]);
California]);
D ([... a]);
E ([... a]);
Fa]);
Georgia]);
Decir ah]);
Este fragmento solo presenta el código utilizado en las pruebas de rendimiento, no realiza pruebas en sí mismo.
Comparación para navegadores: Chrome v78.0.0, Safari v13.0.4 y Firefox v71.0.0
|
Soy bastante nuevo en JavaScript y necesitaba esta funcionalidad. Simplemente escribí esto:
function removeFromArray (matriz, elemento, índice) {
while ((index = array.indexOf (item))> -1) {
array.splice (índice, 1);
}
}
Luego, cuando quiera usarlo:
// Configurar algunos datos ficticios
var dummyObj = {nombre: "miau"};
var dummyArray = [dummyObj, "elemento1", "elemento1", "elemento2"];
// Elimina los datos ficticios
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "elemento2");
Salida: como se esperaba.
["elemento1", "elemento1"]
Es posible que tenga necesidades diferentes a las mías, por lo que puede modificarlo fácilmentepara adaptarse a ellos. Espero que esto ayude a alguien.
|
Si tiene objetos complejos en la matriz, ¿puede usar filtros?
En situaciones en las que $ .inArray o array.splice no son tan fáciles de usar. Especialmente si los objetos son quizás poco profundos en la matriz.
P.ej. si tiene un objeto con un campo Id y desea que el objeto se elimine de una matriz:
this.array = this.array.filter (función (elemento, i) {
return element.id! == idToRemove;
});
|
Quiero responder en base a ECMAScript 6. Suponga que tiene una matriz como la siguiente:
sea ​​arr = [1,2,3,4];
Si desea eliminar en un índice especial como 2, escriba el siguiente código:
arr. empalme (2, 1); // => arr se convirtió en [1,2,4]
Pero si desea eliminar un elemento especial como 3 y no conoce su índice, haga lo siguiente:
arr = arr.filter (e => e! == 3); // => arr se convirtió en [1,2,4]
Sugerencia: utilice una función de flecha para filtrar la devolución de llamada a menos que obtenga una matriz vacía.
|
Actualización: este método se recomienda solo si no puede usar ECMAScript 2015 (anteriormente conocido como ES6). Si puede usarlo, otras respuestas aquí proporcionan implementaciones mucho más ordenadas.
Esta esencia aquí resolverá su problema y también eliminará todas las apariciones del argumento en lugar de solo 1 (o un valor especificado).
Array.prototype.destroy = function (obj) {
// Devuelve nulo si no se encontraron y eliminaron objetos
var destruido = nulo;
para (var i = 0; i  3
x.destroy (falso); // => falso
X; // => [1, 2, verdadero, indefinido]
x.destroy (verdadero); // => verdadero
x.destroy (indefinido); // => indefinido
X; // => [1, 2]
x.destruir (3); // => nulo
X; // => [1, 2]
|
Actualización ES10
Esta publicación resume los enfoques comunes para la eliminación de elementos de la matriz a partir de ECMAScript 2019 (ES10).
1. Casos generales
1.1. Eliminando el elemento Array por valor usando .splice ()
| En el lugar: Sí |
| Elimina duplicados: Sí (bucle), No (indexOf) |
| Por valor / índice: Por índice |
Si conoce el valor que desea eliminar de una matriz, puede usar el método de empalme. Primero debe identificar el índice del elemento de destino. Luego usa el índice como el elemento de inicio y elimina solo un elemento.
// Con un bucle 'for'
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
para (sea i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Con el método .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Eliminando el elemento Array usando el método .filter ()
| En el lugar: No |
| Elimina duplicados: Sí |
| Por valor / índice: Por valor |
El elemento específico se puede filtrar de la matriz, proporcionando una función de filtrado. A continuación, se llama a dicha función para cada elemento de la matriz.
valor constante = 3
sea ​​arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
1.3. Eliminar el elemento Array ampliando Array.prototype
| En el lugar: Sí / No (Depende de la implementación) |
| Elimina duplicados: Sí / No (Depende de la implementación) |
| Por valor / índice: Por índice / Por valor (Depende de la implementación) |
El prototipo de Array se puede ampliar con métodos adicionales. Estos métodos estarán disponibles para su uso en matrices creadas.
Nota: Algunos consideran que extender prototipos de objetos de la biblioteca estándar de JavaScript (como Array) es un antipatrón.
// In situ, elimina todo, por implementación de valor
Array.prototype.remove = function (item) {
para (sea i = 0; i  = ES10)
| En el lugar: No |
| Elimina duplicados: Sí |
| Por valor / índice: Por valor |
ES10 introdujo Object.fromEntries, que puede serse utiliza para crear la matriz deseada a partir de cualquier objeto similar a una matriz y filtrar elementos no deseados durante el proceso.
objeto constante = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Entradas de objeto (objeto)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Casos especiales
2.1 Eliminar elemento si está al final de la matriz
2.1.1. Cambiar la longitud de la matriz
| En el lugar: Sí |
| Elimina duplicados: No |
| Por valor / índice: N / A |
Los elementos de JavaScript Array se pueden eliminar del final de una matriz estableciendo la propiedad length en un valor menor que el valor actual. Se eliminará cualquier elemento cuyo índice sea mayor o igual que la nueva longitud.
const arr = [1, 2, 3, 4, 5, 6];
longitud arr. = 5; // Establecer longitud para eliminar elemento
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Usando el método .pop ()
| En el lugar: Sí |
| Elimina duplicados: No |
| Por valor / índice: N / A |
El método pop elimina el último elemento de la matriz, devuelve ese elemento y actualiza la propiedad length. El método pop modifica la matriz en la que se invoca. Esto significa que, a diferencia de eliminar, el último elemento se elimina completamente y la longitud de la matriz se reduce.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // devuelve 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Eliminando elemento si está al comienzo de la matriz
| En el lugar: Sí |
| Elimina duplicados: No |
| Por valor / índice: N / A |
El método .shift () funciona de manera muy similar al método pop, excepto que elimina el primer elemento de una matriz de JavaScript en lugar del último. Cuando se quita el elemento, los elementos restantes se desplazan hacia abajo.
const arr = [1, 2, 3, 4];
arr.shift (); // devuelve 1
console.log (arr); // [2, 3, 4]
2.3. Eliminar elemento si es el único elemento en la matriz
| En el lugar: Sí |
| Elimina duplicados: N / A |
| Por valor / índice: N / A |
La técnica más rápida es establecer una variable de matriz en una matriz vacía.
sea ​​arr = [1];
arr = []; // matriz vacía
Alternativamente, se puede utilizar la técnica de 2.1.1 estableciendo la longitud en 0.
|
Nunca debes mutar tu matriz. Ya que esto va en contra del patrón de programación funcional. Puede crear una nueva matriz sin hacer referencia a la matriz cuyos datos desea cambiar utilizando el filtro del método ECMAScript 6;
var myArray = [1, 2, 3, 4, 5, 6];
Suponga que desea eliminar 5 de la matriz, simplemente puede hacerlo así:
myArray = myArray.filter (valor => valor! == 5);
Esto le dará una nueva matriz sin el valor que quería eliminar. Entonces el resultado será:
[1, 2, 3, 4, 6]; // 5 se ha eliminado de esta matriz
Para una mayor comprensión, puede leer la documentación de MDN en Array.filter.
|
Un enfoque ECMAScript 2015 más moderno (anteriormente conocido como Harmony o ES 6). Dado:
elementos const = [1, 2, 3, 4];
índice constante = 2;
Entonces:
items.filter ((x, i) => i! == índice);
Flexible:
[1, 2, 4]
Puede utilizar Babel y un servicio polyfill para asegurarse de que sea compatible con todos los navegadores.
|
Puede hacer un bucle hacia atrás para asegurarse de no estropear los índices, si hay varias instancias del elemento.
var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];
/ * Código importante * /
para (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Demo en vivo
|
Tiene de 1 a 9 en la matriz y desea eliminar 5. Utilice el siguiente código:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return m! == 5;
});
console.log ("nuevo Array, 5 eliminado", newNumberArray);
Si desea varios valores. Ejemplo: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("nueva matriz, 1,7 y 8 eliminados", newNumberArray);
Si desea eliminar un valor de matriz en una matriz. Ejemplo: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (m);
});
console.log ("nuevo Array, [3,4,5] eliminado", newNumberArray);
Incluye navegador compatible es enlace.
|
1
2
3
4
Siguiente
Pregunta muy activa. Gana 10 de reputación para responder a esta pregunta. El requisito de reputación ayuda a proteger esta pregunta del spam y de la actividad sin respuesta.
No es la respuesta que estás buscando? Explore otras preguntas etiquetadas como matrices javascript o haga su propia pregunta.